package chapter_06;

// 介绍类

/*
1. 类基础
        A. 类的通用格式
        class classname {
            type instance-variable1;
            type instance-variable2;
            // ...
            type instance-variableN;
            type methodname1(parameter-list) {
            // body of method
            }
            type methodname2(parameter-list) {
            // body of method
            }
            // ...
            type methodnameN(parameter-list) {
            // body of method
            }
        }

        B. 简单的类
        略。

2. 声明对象
classname class-var = new classname( );

3. 给对象引用变量赋值
当你将一个对象引用赋值给另一个对象引用时，你并没有创建该对象的一个拷贝，而是仅仅对引用的一个拷贝。

4. 方法
type name(parameter-list) {
    // body of method
}

5. 构造函数
一旦定义了构造函数，在对象创建后，在new运算符完成前，构造函数立即自动调用。构
造函数看起来有点奇怪，因为它没有任何返回值，即使是void型的值也不返回。

6. this关键字
this可以在引用当前对象的所有方法内使用。也就是说，this总是调用该方法对象的一个引用。
    A. 隐藏的实例变量
    在同一个范围或一个封装范围内，定义二个重名的局部变量在Java中是不合法的。有趣的是，局部变量，包括传递
    到方法的正式的自变量，可以与类的实例变量的名字重叠。在这种情况下，局部变量名就隐藏（hide）了实例变量
    名。
    Box(double width，double height，double depth) {
        this.width = width;
        this.height = height;
        this.depth = depth;
    }

7. 垃圾回收
它是这样工作的：当一个对象的引用不存在时，则该对象被认为是不再需要的，它所占用的内存就被释放掉。

8. finalize()方法
要给一个类增加收尾（finalizer），你只要定义finalize ( )方法即可。Java回收该类的一个对象时，就会调用这个
方法。在finalize ( )方法中，你要指定在一个对象被撤消前必须执行的操作。垃圾回收周期性地运行，检查对象不再
被运行状态引用或间接地通过其他对象引用。就在对象被释放之前，Java运行系统调用该对象的finalize( )方法。
finalize()方法的通用格式如下：
protected void finalize( ) {
    // finalization code here
}
其中，关键字protected是防止在该类之外定义的代码访问finalize()标识符。
理解finalize( )正好在垃圾回收以前被调用非常重要。例如当一个对象超出了它的作用域时，finalize( )并不被调
用。这意味着你不可能知道何时——甚至是否——finalize( )被调用。因此，你的程序应该提供其他的方法来释放由对象
使用的系统资源，而不能依靠finalize( )来完成程序的正常操作。

9. 一个堆栈类
略。
 */


class Box {
    double width;
    double height;
    double depth;

    public static void main(String []args) {
        Box box = new Box(10, 20, 30);
        box.volume();
    }

    Box(double w, double h, double d) {
        // 构造函数，void也不返回
        width = w;
        height = h;
        depth = d;
    }

    void volume() {
        System.out.println("Volume is ");
        System.out.println(width * height * depth);
    }

    double volume2() {
        return width * height * depth;
    }

    protected void finalzie() {
        // Java使用一种不同于C++、自动地处理重新分配内存的方法：垃圾回收技术，它是这样工作的：当一个对象的引用不存在时，则该对
        // 象被认为是不再需要的，它所占用的内存就会被释放掉。
        // finalzie收尾，定义finalzie方法即可。Java在回收该类的一个对象时，就会调用这个方法。其中关键字protected关键字是防止
        // 在该类之外定义的代码访问finalize()标识符。
        // 并不经常使用
    }
}


// 一个堆栈类
class Stack {
    // 先进后出
    int stck[] = new int[10];
    int tos;

    Stack() {
        tos = -1;
    }

    void push(int item) {
        if ( 9 == tos )
            System.out.println("Stack is full.");
        else
            stck[++tos] = item;
    }

    int pop() {
        if ( 0 > tos) {
            System.out.println("Stack underflow.");
            return 0;
        }
        return this.stck[tos--];
    }
}


public class chapter_06 {

    public static void main(String args[]) {
//        Box mybox = new Box(20, 30, 40);
//        double vol;
//		mybox.width = 10;
//		mybox.height = 20;
//		mybox.depth = 15;

//        vol = mybox.width * mybox.depth * mybox.height;
//        System.out.println("Volume is " + vol);
//
//        mybox.volume();
//        System.out.println(mybox.volume2());

        Stack stk1 = new Stack();
        Stack stk2 = new Stack();
        for (int i = 0; i < 10; i++)
            stk1.push(i);
        for (int i = 10; i < 20; i++)
            stk2.push(i);

        System.out.println("stk1:");
        for (int i = 0; i < 10; i++)
            System.out.print(stk1.pop() + " ");
        System.out.println("\nstk2:");
        for (int i = 0; i < 10; i++)
            System.out.print(stk2.pop() + " ");
    }
}
